SPACE 1/SPACE - Library 1 - Volume 1.iso/program/16/whatis.doc

Text File | 1985-11-19 | 47KB | 1,527 lines

! ( n addr  -- )
   Store 32-bit number
!csp ( -- )
   Remember the stack pointer
" ( -- addr len )    string"
   Collect a string from the input stream
"" ( -- addr )    word
   Collect a word from the input stream
", ( addr len -- )
   Place a string at the top of the dictionary
". ( addr -- )
   Display a packed string.  Equivalent to COUNT TYPE
"cat ( startstr-addr endstr-addr -- )
   Append the packed string at startstr-addr to the end of the other one
"compile ( string -- )
   Compile or interpret a word
"copy ( fromaddr toaddr -- )
   Copy a packed string from fromaddr to toaddr
"create ( str -- )
   Define a word from a string on the stack
"load ( string -- )
   Load the file whose name is the packed string on the stack
"move ( addr1 addr2 -- addr2 )
   Move packed string from addr1 to addr2
# ( +l1  --  +l2 )
   Convert a digit in pictured output
#> ( l  --  addr +n )
   End pictured output
#align ( -- n )
   The alignment granularity for the cpu; 2 for 68000
#columns ( -- n )
   The number of text columns on the screen
#fbufs ( -- n )
   The number of file buffers
#fds ( -- n )
   The number of file descriptors available for use by FLOAD
#line ( -- addr )
   User variable containing the line number on the output device
#lines ( -- n )
   The number of text lines on the screen
#out ( -- addr )
   User variable containing the column number on the output device
#s ( +l  --  0 0 )
   Convert rest of digits in pictured output
#thread ( -- n )
   The number of threads used by the dictionary hashing scheme
#tib ( -- addr )
   Size of Terminal Input Buffer
#times ( -- )
   Number of times to re-interpret command line
#user ( -- n )
   The first unused USER area offset
#vocs ( -- n )
   The number of vocabularies that can be in the search order at one time
' ( -- addr )    name
   Find a word in the dictionary
'tib ( -- addr )
   Variable containing the address of the terminal input buffer
'user# ( -- user# )    word
   Find the user number associated with the word if there is one
'word ( -- addr )
   Address where WORD puts its string
( ( -- )
   Begin a comment
(") ( -- addr len )
   Run-time word compiled by "
("s) ( -- addr )
   Run-time word compiled by [""]
(') ( -- acf )
   Run-time word compiled by [']
(+loop) ( n -- )
   Run-time word compiled by +LOOP
(.") ( -- )
   Run-time word compiled by ."
(.) ( n -- addr len )
   Convert a signed number to a character string
(.s ( -- )
   Display the contents of the data stack
(;code) ( -- )
   Run-time word compiled by ;CODE and DOES>
(?do) ( end start -- )
   Run-time word compiled by ?DO
(?leave) ( flag -- )
   Run-time word compiled by ?LEAVE
(abort ( -- )
   Interpret keyboard commands
(abort") ( flag -- )
   Run-time word compiled by ABORT"
(bye ( -- )
   Exit from Forth
(cd ( path -- )
   Change current directory
(cold-hook ( -- )
   Place to install user-defined initialization code
(compile) ( acf -- )
   Compile a compilation address into the dictionary
(cr ( -- )
   Output a carriage return character
(create ( -- )    name
   Default implementation of CREATE
(disk-free ( -- bytes-free )
   Return number of free bytes on current drive
(do) ( end start -- )
   Run-time word compiled by DO
(emit ( char -- )
   Run-time word compiled by ENDCASE
(endof) ( -- )
   Run-time word compiled by ENDOF
(exec ( program-filename command-tail -- )
   Execute a TOS program
(expect ( addr +n -- )
   Show files matching pattern
(forget) ( addr -- )
   Reclaim the dictionary space after addr
(interactive? ( -- flag )
   True if the input stream is interactive
(interpret ( -- )
   Interpret the input stream
(is ( action-acf deferred-acf -- )
   Install a new action in a DEFER word
(is) ( action-acf -- )
   Run-time word compiled by IS
(l.) ( l -- addr len )
   Convert a signed 32-bit number to a character string
(leave) ( -- )
   Run-time word compiled by LEAVE
(lf ( -- )
   Output a linefeed character
(literal? ( str -- str false | literal true )
   Check to see if a string is a number during interpreting or compilation
(load ( fd -- )
   Load the file whose file descriptor is fd
(loop) ( -- )
   Run-time word compiled by LOOP
(md ( path -- )
   Make a new directory
(more
   Display file, pausing at end of screen
(number ( addr -- l )
   Convert a character string to a 32-bit number or abort
(of) ( selector test -- [selector] )
   Run-time word compiled by OF
(patch ( new-number old-number acf -- )
   Substitute new-number for first instance of old-number after acf
(pgo ( addr -- )
   Execute TOS program
(pload ( program-filename command-tail -- addr )
   Load a TOS program
(prompt ( -- )
   Display a prompt on the screen
(quit ( -- )
   Interpret keyboard commands
(rd ( path -- )
   Delete a directory
(rename ( old-name new-name -- )
   Rename a file
(rstrace ( end-addr start-addr -- )
   Display words nested on the return stack image between end and start
(s ( -- )    stack-comment
   Alternate from of stack comment
(see) ( acf -- )
   Decompile the word
(set-relocation-bit ( addr -- addr )
   Set the relocation bit corresponding to the address addr
(size ( match-str -- )
   Show sizes of files matching pattern
(tail
   Display the end of the file, pausing at end of screen
(type ( addr +n -- )
   Display n characters
(u.) ( u -- addr len )
   Convert an unsigned number to a character string
(ul.) ( ul -- addr len )
   Convert an unsigned 32-bit number to a character string
(warm-hook ( -- )
   Place to install a user-defined handler for hardware exceptions
(where ( -- )
   Print a message telling where in the input stream you are
(word ( char -- addr )
   Collect char-delimited input string
* ( n1 n2  --  n3 )
   Multiply n1 times n2
*/ ( n1 n2 n3  -- n4 )
   n1*n2/n3
*/mod ( n1 n2 n3  -- n4 n5 )
   n4 is remainder, n5 is quotient of n1*n2/n3
+ ( n1 n2 -- n3 )
   Add n1+n2
+! ( n addr -- )
   Add n to number stored at addr
+dis ( -- )
   Continue disassembling from the last stopping point
+fseek ( l.offset fd -- )
   Move position within a file
+loop ( n -- )
   End of DO .. +LOOP; increment by n
+str ( addr1 -- addr2 )
   Find the end of the packed string at addr1
, ( n -- )
   Place a number in the dictionary
," ( -- )    string"
   Place a string at the top of the dictionary
- ( n1 n2 -- n3 )
   Subtract n1-n2
-rot ( n1 n2 n3  ---  n3 n1 n2 )
   Shuffle 3 stack items
-trailing ( addr +n1  --  addr +n2 )
   Remove trailing blanks
. ( n  -- )
   Print a number
." ( -- )
   Display a string
.( ( -- )
   Display a string immediately
.calls ( acf -- )
   Show all the words which call the word acf
.current-word ( ip -- )
   Print the name of a word given any address within its body
.d ( n -- )
   Display n in decimal without changing BASE
.date ( day month year -- )
   Display the date from numbers on the stack
.dir
   Print current directory name
.disk-free     drive-name
   Show free space on current drive
.id ( anf -- )
   Display the name of a word from its name field address
.month ( month -- )
   Display the name of the numbered month
.name ( acf -- )
   Display the name of a word from its compilation address
.now ( -- )
   Display the current time
.r ( n +n -- )
   Print number in fixed width field
.s ( -- )
   Display the contents of the data stack
.tab ( string-length -- )
   Advance to next output field
.time ( seconds minutes hours -- )
   Display the time from numbers on the stack
.today ( -- )
   Display today's date
.version ( -- )
   Displays the version number of the Forth system
.x ( n -- )
   Display n in hex without changing BASE
/ ( n1 n2  --  n3 )
   Divide n1/n2
/c ( -- n )
   Multiply by the size of a byte
/fbuf ( -- n )
   The number of bytes in a file buffer
/fd ( -- n )
   The number of bytes in a file descriptor
/l ( -- n )
   Multiply by the size of a longword
/link ( -- n )
   The number of bytes in a dictionary link; 4
/mod ( n1 n2  --  n3 n4 )
   n3 is remainder, n4 is quotient of n1/n2
/n ( -- n )
   Multiply by the size of a stack item
/token ( -- n )
   The number of bytes in a compiled address; 4
/w ( -- n )
   Multiply by the size of a word
0< ( n  --  flag )
   Is n < 0 ?
0<= ( n  --  flag )
   True if n is less than or equal to zero
0<> ( n  --  flag )
   True if n is not equal to zero
0= ( n  --  flag )
   Is n = 0 ?
0> ( n  --  flag )
   Is n > 0 ?
0>= ( n  --  flag )
   True if n is greater than or equal to zero
1+ ( n1  --  n2 )
   Add 1
1- ( n1  --  n2 )
   Subtract 1
16-bit ( -- )
   Abort since this isn't a 16-bit system
16\ ( -- )
   Ignore rest of line since this isn't a 16-bit system
2! ( n1 n2 addr -- )
   Store 2 numbers
2* ( n1 -- n2 )
   Multiply by 2
2+ ( n1 -- n2 )
   Add 2
2- ( n1 -- n2 )
   Subtract 2
2/ ( n1 -- n2 )
   Divide by 2
25lines ( -- )
   Display text in 25 lines x 80 columns format; monochrome only
2@ ( addr -- n1 n2 )
   Fetch 2 numbers
2constant ( n1 n2  -- )
   Define a 2-number constant
2drop ( n1 n2  -- )
   Remove 2 numbers from stack
2dup ( n1 n2 --  n1 n2  n1 n2 )
   Duplicate 2 numbers
2over ( n1 n2  n3 n4  --  n1 n2  n3 n4  n5 n6 )
   Copy 2 numbers
2rot ( n1 n2  n3 n4  n5 n6  --  n3 n4  n5 n6  n1 n2 )
   Rotate 3 pairs of numbers
2swap ( n1 n2  n3 n4  --  n3 n4  n1 n2 )
   Exchange 2 pairs of numbers
2variable ( -- )
   Define a variable for 2 numbers
32-bit ( -- )
   Do nothing, since this is a 32-bit system
32\ ( -- )
   Interpret rest of line since this is a 32-bit system
3dup ( a b c -- a b c a b c )
   Duplicate 3 stack items
4* ( n1 -- n2 )
   Multiply by 4; use /N* instead
40lines ( -- )
   Display text in 40 lines x 80 columns format; monochrome only
44lines ( -- )
   Display text in 44 lines x 80 columns format; monochrome only
4dup ( a b c d-- a b c d a b c d )
   Duplicate 4 stack items
50lines ( -- )
   Display text in 50 lines x 80 columns format; monochrome only
8* ( n1 -- n2 )
   Multiply by 8
: ( -- sys )    name
   Start compiling a new procedure
; ( -- )
   Finish compiling a procedure
;code ( C,I,206 )
   Start an assembly language run-time clause
< ( n1 n2  --  flag )
   Is n1 < n2 ?
<# ( -- )
   Initialize pictured output
<< ( n1 cnt -- n2 )
   Left shift count places
<<a ( n1 cnt -- n2 )
   Arithmetic left shift count places
<= ( n1 n2  --  flag )
   True if n1 is less than or equal to n2
<> ( n1 n2  --  flag )
   True if n1 is not equal to n2
<mark ( -- addr )
   Remember target of backward branch
<resolve ( addr -- )
   Finish a backward branch
<w@ ( addr -- n )
   Fetch the signed word at addr
= ( n1 n2  --  flag )
   Is n1 = n2 ?
> ( n1 n2  --  flag )
   Is n1 > n2 ?
>= ( n1 n2  -- flag )
   True if n1 is greater than or equal to n2
>> ( n1 cnt -- n2 )
   Right shift count places
>>a ( n1 cnt -- n2 )
   Arithmetic right shift count places
>body ( addr1 -- addr2 )
   Find the data storage address for the word at acf
>dmy ( GEMDOS-packed-date -- day month year )
   Convert to GEMDOS packed date format
>hms ( GEMDOS-packed-time -- seconds minutes hours )
   Convert from GEMDOS packed time format
>in ( -- addr )
   Not Implemented
>link ( addr1 -- addr2 )
   Find link field from compilation address
>mark ( -- addr )
   Remember location of forward branch
>name ( addr1 -- addr2 )
   Find name field from compilation address
>r ( n -- )
   Move number to return stack
>relbit ( addr -- offset rel-table-addr )
   Convert addr to a bit offset and the relocation table address
>resolve ( addr -- )
   Finish a forward branch
>threads ( voc-acf -- thread )
   Find the threads for a vocabulary
>type ( addr +n -- )
   Display characters and store them at PAD
>user ( apf -- user-var-addr )
   Find a user number that is in the parameter field
>user# ( acf -- user# )
   Find the user number associated with the word if there is one
? ( addr  -- )
   Display the contents of a variable
??cr ( -- )
   New line if not already at left side of line
?branch ( flag -- )
   High-level conditional branch
?comp ( -- )
   Abort if not compiling
?cr ( -- )
   New line if fewer than no space left on this one
?csp ( -- )
   Check stack pointer again saved value
?dnegate ( d1 f -- d2 )
   Obsolete
?do ( w1 w2 -- )
   Begin a ?DO .. LOOP to be executed 0 or more times
?dup ( n  --  n n )
   Duplicate if non-zero
?empty ( stack -- flag )
   True if the user stack is empty
?enough ( n -- )
   Abort if the stack contains fewer than n numbers
?exec ( -- )
   Abort if not interpreting
?leave ( flag -- )
   Exit from a DO .. LOOP if flag is nonzero
?line ( n -- )
   New line if fewer than n spaces left on this one
?lnegate ( l1 f -- l2 )
   Negate if flag is true
?missing ( flag -- )
   Abort if nonzero
?negate ( n f -- -n )
   Negate if flag is true
?pairs ( n1 n2 -- )
   Abort if n1 is not equal to n2
?stack ( -- )
   Abort if the stack pointer is out of range
?to-column ( -- )
   Advance output to indicated column or start new line
@ ( addr  --  n )
   Fetch 32-bit number
a:
   Select drive A
abort ( -- )
   Conditional abort with message
abs ( n -- u )
   Absolute value
alias ( -- )    new-name existing-name
   Create a new name for an existing word
align ( -- )
   Make sure the dictionary pointer is on a machine word boundary
aligned ( addr1 -- addr2 )
   Adjust an address to a machine word boundary
alloc-mem ( nbytes -- addr )
   Allocate nbytes of memory and return its address
allot ( n -- )
   Allocate space in the dictionary
also ( -- )
   Extend the search order
and ( n1 n2 -- n3 )
   Logical and
another-file? ( -- more? )
   Select next matching file name
another? ( -- [ anf ] more? )
   Select next word in vocabulary
append-open ( name -- )
   Open file for appending
append-to-file ( -- )    filename
   Temporarily redirect output to the end of a file
appending     filename
   Open file for appending
ascii ( -- char )    word
   Numerical value of first ascii character of next word
assembler ( -- )
   Vocabulary containing the assembler
at ( line column -- )
   Move the cursor to line,column on the screen
b:
   Select drive B
backspaces ( n -- )
   Output n backspaces
base ( --  addr )
   Variable containing number base
base-page ( -- addr )
   The address of Forth's base page
bdos: ( function# -- )
   Begin defining a word to execute a GEMDOS/BDOS function
beep ( -- )
   Ring the bell
begin ( -- )
   Beginning of BEGIN .. WHILE .. REPEAT loop
bell ( -- n )
   The ascii code for the bell character
between ( n min max -- f )
   True if min <= n <= max
binary ( -- )
   Set number base to two
bios: ( function# -- )
   Begin defining a word to execute a BIOS function
bitclear ( bit# addr -- )
   Clears bit number bit# in the array at addr
bitset ( bit# addr -- )
   Sets bit number bit# in the array at addr
bittest ( bit# addr -- flag )
   True if bit number bit# in the array at addr is set
bl ( -- n )
   The ascii code for the blank character; decimal 32
blank ( addr u -- )
   Set u bytes of memory to blank
blk ( -- addr )
   Not Implemented
block ( u -- addr )
   Not Implemented
blword ( -- addr )    word
   Get a blank-delimited word and return it as a packed string
body> ( addr1 -- addr2 )
   Find compilation address form parameter field
bounds ( addr1 len -- addr2 addr1 )
   Convert address and length to endaddr startaddr
branch ( -- )
   High-level unconditional branch
bs ( -- n )
   The ascii code for the backspace character
buffer ( u -- addr )
   Not Implemented
bye ( -- )
   Store 8-bit number
c, ( n -- )
   Place a byte in the dictionary
c:
   Select drive C
c@ ( addr  --  n )
   Fetch 8-bit number
ca+ ( addr1 index -- addr2 )
   Increment by index times the size of a byte
ca1+ ( addr1 -- addr2 )
   Increment by the size of a byte
caller-stack ( -- addr )
   USER variable containing the cold-start value of the stack pointer
canonical ( addr -- addr )
   Convert a string to lower case
caps ( -- addr )
   USER variable controlling upper case/lower case sensitivity
caps-comp ( addr1 addr2 len -- n )
   Compare two byte arrays ignoring case.  n is 0 if they are the same
carret ( -- n )
   The ascii code for the carriage return character
case ( selector -- selector )
   Begins a CASE ... ENDCASE conditional
cd     directory
   Change current directory
cdis ( acf -- )
   Disassemble the code word at acf
chdir
   Same as CD
child-status ( -- addr )
   Status returned by last TOS program executed
clear ( ??? -- )
   Empty the data stack
clearstack ( stack -- )
   Empty a user stack
close ( fd -- )
   Close a file
close-files ( -- )
   Close all the open file
cmove ( addr1 addr2 u -- )
   Copy u bytes from addr1 to addr2
cmove> ( addr1 addr2 u -- )
   Copy u bytes from addr1 to addr2
cnot ( c1 -- c2 )
   8-bit logical inversion
code ( -- sys )    name
   Start defining an assembly language procedure
cold ( -- )
   Initializes the Forth system when it is first started
cold-hook ( -- )
   Vocabulary containing helper words for the command completion feature
command: ( -- )    name program-filename
   Defining word for commands to execute TOS programs
comp ( addr1 addr2 len -- n )
   Compare two byte arrays.  n is 0 if they are the same
compare ( addr1 addr2 len -- n )
   Compare two byte arrays.  n is 0 if they are the same
compile ( -- )
   Compile next word at run time
compile-do-defined ( cfa -1 | cfa 1 -- )
   Called to handle a predefined word during compilation
compile-do-literal ( l -- )
   Called to handle number during compilation
compile-do-undefined ( str -- )
   Called to handle an undefined word during compilation
constant ( n -- )    name
   Define a constant
context ( -- addr )
   Array of vocabularies to search
control ( -- char )    word
   Control character number of first character of next word
convert ( +l1 addr1  --  +l2 addr2 )
   Convert characters to a number
copy1     source-file destination-file
   Manual file copy
count ( addr1 --  addr2 +n )
   Unpack a packed string
cr ( -- )
   Initial action for words defined by DEFER
crash-rstrace ( -- )
   Display the return stack image saved from the last crash
create ( -- )    name
   Generic defining word
creset ( byte-mask addr -- )
   Clear bits within the byte at addr
crlf ( -- )
   Go to next line
crlf ( -- )
   Output a carriage return & linefeed; adjust #LINE & #OUT
csearch ( c start-addr end-addr -- loc true | false )
   Search for byte c between start-addr and end-addr
cset ( byte-mask addr -- )
   Set bits within the byte at addr
cstr ( addr -- cstr-addr )
   Convert Forth string to C string
cstrlen ( cstr-addr -- len )
   Length of a null-terminate C string
ctoggle ( byte-mask addr -- )
   Invert the masked bits within the byte at addr
current ( -- addr )
   Variable containing compilation vocabulary
cursor-off ( -- )
   Turns off the display cursor
cursor-on ( -- )
   Turns on the display cursor
d+ ( wd1 wd2 -- wd3 )
   Obsolete
d- ( wd1 wd2 -- wd3 )
   Obsolete
d. ( d -- )
   Obsolete
d.r ( d +n-- )
   Obsolete
d0< ( d -- flag )
   Obsolete
d0> ( d -- flag )
   Obsolete
d:
   Select drive D
d< ( d1 d2 -- flag )
   Obsolete
d< ( d1 d2 -- flag )
   Obsolete
d> ( d1 d2 -- flag )
   Obsolete
dark ( -- )
   Use inverse video for future text; usually white-on-black
decimal ( -- )
   Set number base to 10
defer ( -- )    name
   Find compilation address of word from the input stream
definer ( acf -- definer-acf )
   Find the word which defined the word at acf
definitions ( -- )
   Set compilation vocabulary
del
   Same as DELETE
delete     filename
   Delete a file
delete ( name -- flag )
   Delete a file
delete-char ( -- )
   Delete the character under the cursor from the screen; doesn't work
delete-line ( -- )
   Delete the current line from the screen
delimiter ( -- addr )
   USER variable containing the actual delimiter found by WORD
depth ( -- +n )
   How many numbers on stack?
df
   Same as FREE
digit ( char base -- digit true | char false )
   Convert a character to a digit
dir
   Same as FILES
dir-attributes ( -- addr )
   Variable containing attributes for file search
dis ( -- )    code-word-name
   Disassemble the code word
disassembler ( -- )
   Vocabulary containing helper words for the disassembler
dma-buffer ( -- addr )
   Buffer containing the file info found by ANOTHER-FILE?
dmax ( d1 d2 -- d3 )
   Obsolete
dmin ( d1 d2 -- d3 )
   Obsolete
dmy> ( day month year -- GEMDOS-packed-date )
   Convert from GEMDOS packed date format
dnegate ( d1 -- d2 )
   Obsolete
do ( n1 n2 -- )
   Beginning of DO .. LOOP
do-defined ( cfa -1 | cfa 1 -- ?? )
   Called to handle a predefined word during interpreting or compilation
do-literal ( literal -- ?? )
   Called to handle number during interpreting or compilation
do-undefined ( str -- )
   Called to handle an undefined word during interpreting or compilation
dodoesaddr ( -- addr )
   Variable containing the address of the DODOES routine
does> ( -- addr )
   Start run-time clause for defining words
down ( -- )
   Move the cursor down one line
download ( -- )    filename
   Receive binary data from the serial port and store into a file
dpl ( -- addr )
   Variable containing the position of the decimal point in last number input
drop ( n -- )
   Remove n from stack.
dst? ( -- flag )
   True if daylight savings time
du ( addr -- addr+64 )
   Display 64 bytes of memory starting at addr
du< ( d1 d2 -- flag )
   Obsolete
du<= ( d1 d2 -- flag )
   Display contents of memory
dump ( addr len -- )
   Display len bytes of memory starting at addr
dup ( n -- n n )
   Duplicate n.
editor ( -- )
   Not Implemented
else ( -- )
   Execute following code if IF failed
emit ( char -- )
   Display character
empty-buffers ( -- )
   Not Implemented
end-code ( sys -- )
   Stop defining an assembly language procedure
end-string-array ( -- )
   Finish defining a string array
endcase ( selector -- )
   Terminates a CASE ... ENDCASE conditional
endof ( -- )
   Terminates an OF ... ENDOF clause within a CASE ... ENDCASE conditional
entry ( -- addr )
   USER variable used to implement multitasking
eof ( -- n )
   Value returned by FGETC upon end of file
era
   Same as DELETE
erase ( addr u -- )
   Set u bytes of memory to 0
erase-screen ( -- )
   Clear the screen
error-output ( -- )
   Select the error output stream
eval ( addr len -- )
   Interpret from a string
even ( n1 -- n2 )
   Adjust a number to make it even.  n2 >= n1
exec ( -- )    program-filename command-tail
   Execute TOS program
execute ( addr -- )
   Execute word on stack
exit ( -- )
   Return from current word
exit? ( -- flag )
   True if the user wants the output to be terminated
expect ( addr +n -- )
   Open a file for the keyboard
false ( -- 0 )
   The value FALSE, which is 0
fexit ( -- )
   Ignore the rest of the current input file
fflush ( fd -- )
   Write out buffered bytes to file
fgetc ( fd -- byte )
   Read a byte from a file
fgets ( addr count fd -- nread )
   Read a string from a file
file-exists? ( name -- f )
   True if the named file already exists
file-pattern ( pattern-string -- )
   Initialize the file search pattern for future calls to ANOTHER-FILE?
file-protection ( -- addr )
   Variable containing the attributes for newly-created files
filec! ( byte l.addr fd -- )
   Write a byte to a file
filec@ ( l.addr fd -- byte )
   Read a byte from a file
files     pattern
   Show files matching pattern; default *.*
files ( -- )
   Display names of files
fill ( addr u byte  -- )
   Set u bytes of memory to byte
find ( addr1 -- addr2 n )
   Find a word in the dictionary
flip ( w1 -- w2 )
   Swap bytes with lower word
fload ( -- )    name
   Interpret a file
flush ( -- )
   Not Implemented
follow ( threads -- )
   Prepare to scan a vocabulary; see ANOTHER?
forget ( -- )    name
   Remove word from dictionary
forth ( -- )
   The main vocabulary
forth-83 ( -- )
   Assert the dialect
fputc ( byte fd -- )
   Write a byte to a file
fputs ( addr count fd -- )
   Write a string to a file
free-mem ( addr nbytes -- )
   Frees memory allocated by ALLOC-MEM
fseek ( l.addr fd -- )
   Set position within a file
fseek-from-end ( l.offset fd -- )
   Set position from end of file
fsize ( fd -- l.size )
   Find size of a file
fstr ( cstr-addr -- addr2 )
   Convert C string to Forth string
ftell ( fd -- l.addr )
   Find current position within file
getcword ( addr delim fd -- addr )
   Read delimited string from file
getword ( addr fd -- addr )
   Read non-blanks from file
here ( -- addr )
   Address of top of dictionary
hex ( -- )
   Set number base to 16
hidden ( -- )
   Vocabulary containing words used only to implement other words
hide ( -- )
   Make the most recent word invisible
hms> ( seconds minutes hours -- GEMDOS-packed-time )
   Convert to GEMDOS packed time format
hold ( char  -- )
   Insert char in pictured output
i ( -- n )
   Loop index
if ( flag -- )
   Execute following code if flag is true
ifd ( --  addr )
   Variable for input file descriptor
ifdef ( -- )    word
   Continue interpreting if word is defined
ifend ( -- )
   Conditional useable while interpreting
ifndef ( -- )    word
   Continue interpreting if word is not defined
iftrue ( [ flag ] -- )
   Conditional useable while interpreting
ignoredom ( -- )
   Vocabulary containing conditional compilation words
immediate ( -- )
   Mark last word as immediate
immediate? ( acf -- flag )
   True if word is immediate
in-file ( -- addr )
   Variable containing the file descriptor of the current input file
init-malloc ( -- )
   Initialize the ALLOC-MEM memory allocator
init-relocation ( -- )
   Initialize the relocation table
init-user ( -- )
   Initialize the USER area at startup time
insert-char ( char -- )
   Insert the character at the cursor position; doesn't work right
insert-line ( -- )
   Insert a new line on the screen at the cursor position
interactive? ( -- flag )
   Interpret the input stream
interpret-do-defined ( cfa -1 | cfa 1 -- ?? )
   Called to handle a predefined word during interpreting
interpret-do-literal ( l -- l | n )
   Called to handle number during interpreting
interpret-do-undefined ( str -- )
   Called to handle an undefined word during interpreting
is ( action-acf -- )    name
   Install a new action in a DEFER word
is-now ( seconds minutes hours -- )
   Set the time
is-today ( day month year -- )
   Set the date
isdst ( -- addr )
   Variable containing true if daylight savings time
j ( -- n )
   Loop index for outer loop
k ( -- n )
   Loop index for second outer loop
key ( -- char )
   Vocabulary containing keystroke definitions for the command line editor
kill-line ( -- )
   Clear the current line to the right of the cursor
kill-screen ( -- )
   Clear the screen from the cursor position onward
l* ( l1 l2 -- l3 )
   Explicit 32-bit multiplication
l+ ( l1 l2 -- l3 )
   Explicit 32-bit addition
l+! ( l addr  -- )
   Add l to the 32-bit number at addr
l, ( l -- )
   Place a longword in the dictionary
l- ( l1 l2 -- l3 )
   Explicit 32-bit subtraction l1-l2
l->n ( l -- n )
   Convert a longword to a stack item; noop on this system
l->w ( l -- w )
   Convert a longword to a word
l. ( l -- )
   Display a 32-bit signed number
l.r ( l +n -- )
   Display a 32-bit signed number in a fixed-width field
l0= ( l  --  flag )
   True if l is zero
l2/ ( l1 -- l2 )
   Explicit 32-bit divide-by-2
l2/ ( l1 -- l2 )
   Explict 32-bit arithmetic right shift
l2dup ( l1 l2 -- l1 l2 l1 l2 )
   Duplicate a pair of longwords
l< ( l1 l2  --  flag )
   True if l1 is less than l2
l<< ( l1 cnt -- l2 )
   Explicit 32-bit left shift count places
l<<a ( l1 cnt -- l2 )
   Explicit 32-bit arithmetic shift count places
l= ( l1 l2 -- flag )
   True if l1 is equal to l2
l>= ( l1 l2 -- flag )
   True if l1 is less than l2; explicitly 32-bit
l>> ( l1 cnt -- l2 )
   Explicit 32-bit right shift count places
l>>a ( l1 cnt -- l2 )
   Explicit 32-bit arithmetic right shift count places
l>name ( addr1 -- addr2 )
   Find name field from link field
l>r ( l -- )
   Move a longword to the return stack
l@ ( addr -- l )
   Fetch the longword at addr
la+ ( addr1 index -- addr2 )
   Increment by index times the size of a longword
la1+ ( addr1 -- addr2 )
   Increment by the size of a longword
labs ( l -- ul )
   Explict 32-bit absolute value
land ( l1 l2 -- l3 )
   Explicit 32-bit logical and
last ( -- addr )
   USER variable containing the name field address of the last word created
lbetween ( l1 lmin lmax -- flag )
   True if lmin <= l1 <= lmax; explicitly 32-bit
lcc ( char -- lower-case-char )
   Convert to lower case
lconstant ( l -- )    name
   Define a 32-bit constant
ldrop ( l -- )
   Remove a longword from the stack
ldup ( l -- l l )
   Duplicate l
leave ( -- )
   Exit from DO .. LOOP
left ( -- )
   Move the cursor left one column
length ( addr -- addr+2 len )
   Unpack a string containing a 16-bit length field
lf ( -- )
   Output a linefeed character and adjust #LINE
light ( -- )
   Use normal video for future text; usually black-on-white
linefeed ( -- n )
   The ascii code for the line feed character
link ( -- addr )
   USER variable containing the address of the next task
link! ( link addr -- )
   Store a dictionary link
link, ( link -- )
   Place a link in the dictionary
link> ( addr1 -- addr2 )
   Find compilation address from link field
link@ ( lfa -- link )
   Fetch a dictionary link
list ( u  -- )
   Not Implemented
literal ( -- n )
   Compile a number
literal? ( str -- str false | literal true )
   Compile an explicit 32-bit number
lmargin ( -- addr )
   Variable containg left margin for output formatting
lmax ( l1 l2 -- l3 )
   Explict 32-bit maximum
lmin ( l1 l2 -- l3 )
   Explict 32-bit minimun
lnegate ( l1 -- l2 )
   Explicit 32-bit negation
lnot ( l1 -- l2 )
   Explicit 32-bit logical inversion
lnover ( l1 n -- l1 n l2 )
   Copy a longword over a normal
lnswap ( l n -- n l )
   Swap a longword and a normal
load ( u -- )
   Not Implemented
lobyte ( n -- c )
   Mask off high bits, leaving the least-significant byte
long? ( -- flag )
   True if the number that was just input contained a decimal point
loop ( -- )
   End of DO .. LOOP
lor ( l1 l2 -- l3 )
   Explicit 32-bit logical or
lose ( -- )
   Compiled in place of an undefined word; aborts
lower ( addr len -- )
   Convert a string to lower case
lr> ( -- l )
   Move a longword from the return stack
ls
   Same as FILES
lswap ( l1 l2 -- l2 l1 )
   Swap 2 longwords
lu< ( ul1 ul2  --  flag )
   True if ul1 is less than ul2
lvariable ( -- )    name
   Define a 32-bit variable
lwithin ( l1 lmin lmax -- flag )
   True if lmin <= l1 < lmax; explicitly 32-bit
lwsplit ( l -- w.low w.high )
   Split a longword into two words
m/mod ( l.dividend n.divisor -- n.rem n.quot )
   Signed 32/normal remainder/quotient
main-task ( -- addr )
   The address of the USER area for the initial task
make ( name -- )
   Create a file
many ( -- )
   Re-interpret this command line until a key is typed
max ( n1 n2  --  n3 )
   n3 is maximum of n1 and n2
max-image ( -- size )
   The size in bytes of the maximum dictionary that may be relocated
md     directory
   Make a new directory
memfree ( -- #bytes )
   Number of bytes Forth can use for scratch storage
memtop ( -- addr )
   Variable containing the address of the top of memory used by Forth
min ( n1 n2  --  n3 )
   n3 is minimum of n1 and n2
mkdir
   Same as MD
mload ( -- )
   Interpret a file coming over the serial port
mod ( n1 n2  -- n3 )
   Remainder of n1/n2
modify ( -- n )
   The code used by OPEN to mean the file is to be read and written
more     filename
   Display contents of file, pausing each page
move ( addr1 addr2 u -- )
   Copy u bytes from addr1 to addr2
mu/mod ( ul n -- n.rem ul.quot )
   Divede longword by normal giving normal remainder and long quotient
multi ( -- )
   Turns on multitasking
mv
   Same as RENAME
n->a ( n -- addr )
   Convert a stack item to an address; noop on this system
n->l ( u -- l )
   Convert a stack item to a longword; noop on this system
n->w ( n -- w )
   Convert a stack item to a word
n>link ( addr1 -- addr2 )
   Find link field from name field
na+ ( addr1 index -- addr2 )
   Increment by index times the size of a stack item
na1+ ( addr1 -- addr2 )
   Increment by the size of a stack item
name> ( addr1 -- addr2 )
   Find compilation address from name field
needs ( -- )    needed-word filename
   Load file if needed-word is not already defined
negate ( n1 -- n2 )
   Change sign
new-file ( name -- )
   Create a new file and open it for writing
newexpect ( addr +n -- )
   Read a line from the keyboard
newline ( -- char )
   The character which terminates a line
next-free-mem ( -- addr )
   Variable containing the address of the end of free memory
nip ( n1 n2 -- n2 )
   Discard the second element from the data stack
nlover ( n1 l -- n1 l n2 )
   Copy a normal over a longword
nlswap ( n l -- l n )
   Swap a normal and a longword
noop ( -- )
   Do nothing
not ( n1 -- n2 )
   One's complement
now ( -- seconds minutes hours )
   The current time of day
npatch ( new-number old-number -- )    word-to-patch
   Substitute new-number for old-number in word-to-patch
nullstring ( -- addr )
   A packed string containing no bytes
number ( addr -- l )
   Convert a character string to a 32-bit number
nuser ( -- )    name
   Define and allocate space for a 32-bit user variable
octal ( -- )
   Set number base to eight
of ( selector test-value -- )
   Begins an OF ... ENDOF clause within a CASE ... ENDCASE conditional
ofd ( --  addr )
   Variable for output file descriptor
off ( addr  -- )
   Store false at addr
ok ( -- )
   Do nothing
on ( addr  -- )
   Store true at addr
only ( -- )
   Sets the minimum search order
open ( name mode -- fd )
   Open a file
or ( n1 n2 -- n3 )
   Logical or
order
   Display the vocabulary search order
order ( -- )
   Display the search order
origin ( -- addr )
   The address of the start of the Forth system
otherwise ( -- )
   Conditional useable while interpreting
over ( n1 n2  --  n1 n2 n3 )
   n3 is a copy of n1.
over-vocabulary ( action-acf voc-acf -- )
   Scan a vocabulary executing action-acf for each word
pack ( addr1 len addr2 -- addr2 )
   Make a packed string at addr2
pad ( --  addr )
   Address of a scratch area
patch ( -- )    replacement-word replaced-word word-to-patch
   Substitute replacement for replaced in word-to-patch
pause ( -- )
   Give other tasks a chance to run
perform ( addr-of-acf -- )
   Execute the word contained in a variable
pick ( n1  --  n2 )
   Copy n-th number
place ( addr1 len addr2 -- )
   Make a packed string at addr2
pload ( -- addr )    program-filename command-tail
   Load TOS program
pop ( stack -- n )
   Pop a number off a user stack
previous ( -- )
   True if character is printable
probably-cfa? ( addr -- flag )
   True if addr looks like a compilation address
prompt ( -- )
   The size of the data stack in bytes
push ( n stack -- )
   Push a number on a user stack
pwd
   Same as DIR
quit ( -- )
   Move number from return stack
r@ ( -- n )
   Copy from return stack
rd     directory
   Delete a directory
read ( -- n )
   The code used by OPEN to mean the file is to be opened for reading
read ( -- n )
   The code used by OPEN to mean the file is to be read
read-binary ( start-addr -- count )
   Receive binary data from the serial port storing it at start-addr
read-open ( name -- )
   Open file for reading
reading     filename
   Open file for reading
reasonable-ip? ( addr -- flag )
   True if addr appears to be inside the body of a colon definition
recursive ( -- )
   Allow a word being defined to call itself recursively
relocation-map ( -- addr )
   The address of the relocation table
rename     old-name  new-name
   Rename a file
repeat ( -- )
   End of BEGIN .. WHILE .. REPEAT loop
restore-output ( -- )
   Go back to the old output stream after ERROR-OUTPUT
reveal ( -- )
   Make the most recent word visible
right ( -- )
   Move the cursor right one column
rm
   Same as DELETE
rmargin ( -- addr )
   Variable containg right margin for output formatting
rmdir
   Same as DELDIR
roll ( n  -- )
   Rotate n numbers
root ( -- )
   Vocabulary selected by ONLY
rot ( n1 n2 n3  ---  n2 n3 n1 )
   Rotate 3 numbers
rp! ( addr -- )
   Change the return stack pointer
rp0 ( --  addr )
   Variable containing the address of the bottom of the return stack
rp@ ( -- addr )
   The address of the top of the return stack
rstrace ( -- )
   Display the words nested on the return stack
s->d ( n -- d )
   Obsolete
s. ( n -- )
   Display n as a signed number
save-buffers ( -- )
   Not Implemented
save-forth ( filename -- )
   Save a non-relocatable image of the Forth dictionary in a TOS file
save-rel ( filename -- )
   Save a relocatable image of the Forth dictionary in a TOS file
save-string ( string1 -- string2 )
   Move a string somewhere else
saved-ip ( -- addr )
   USER variable containing the interpreter pointer for an inactive task
saved-rp ( -- addr )
   USER variable containing the return stack pointer for an inactive task
saved-sp ( -- addr )
   USER variable containing the stack pointer for an inactive task
scr ( --  addr )
   Not Implemented
sdepth ( stack -- depth )
   Number of items on a user-defined stack
seal ( -- )
   Limit the search order
search ( n start end -- loc true | fals )
   Search for n between start-addr and end-addr
see ( -- )    word
   Decompile the word
set-relocation-bit ( addr -- addr )
   Display the machine state saved from the last crash
sift ( string -- )
   Find all words which contain string as part of their name
sifting ( -- )    string
   Find all words which contain string as part of their name
sign ( n  -- )
   Set sign of pictured output
sindex ( addr1 len1 addr2 len2 -- n )
   Find offset within string 1 where string 2 first occurs
single ( -- )
   Turns off multitasking
size ( -- )    pattern
   Show files and sizes; default *.*
skipcword ( char fd -- )    string
   Skip past next occurrence of char in file fd
skipstr ( -- addr len )
   Used to implement words with in-line strings
sp! ( addr -- )
   Change the data stack pointer
sp0 ( --  ADDR )
   Variable containing the address of the bottom of the Data Stack
sp@ ( -- addr )
   The address of the top of the data stack
space ( -- )
   Display a space
spaces ( +n  -- )
   Display n spaces
span ( -- addr )
   Contains # of characters read by EXPECT
splice-relocation ( filename -- )
   Used before SAVE-REL to get the relocation info from the TOS file
ssp ( -- addr )
   Variable containing the previous value of the Supervisor Stack Pointer
stack: ( #bytes -- )    name
   Define a user stack with #bytes of storage space
state ( -- addr )
   Variable that is nonzero in compile state
status ( -- )
   User-settable action to be performed before prompting for input
string-array ( -- )    name
   Begin defining a string array
string-fopen ( addr len -- fd )
   Open a file for a memory string
string-load ( addr len -- )
   Same as EVAL
subroutine: ( addr -- )
   Begin defining a word to execute a subroutine call to addr
substring? ( str1 str2 -- flag )
   True if str1 is a substring of str2
supervisor-state ( -- )
   The processor is put in user state
swap ( n1 n2  --  n2 n1 )
   Exchange top 2 numbers.
sys-(key? ( -- flag )
   True if a key has been typed
sys-emit ( char -- )
   Display character
sys-key ( -- char )
   Read character from keyboard
system ( -- )
   Vocabulary containing GEMDOS interface words
ta1+ ( addr1 -- addr2 )
   Increment by the size of a compiled address
tabstops ( -- addr )
   Variable containing distance between output fields
tail     filename
   Display last 1000 bytes of file
td ( -- ? )
   Interpret next word or number in DECIMAL mode
th ( -- ? )
   Interpret next word or number in HEX mode
then ( -- )
   Terminate an IF ... ELSE ... THEN
tib ( -- addr )
   Terminal Input Buffer
tib-fd ( -- fd )
   File descriptor for the interactive input stream
time-zone ( -- minutes-west-of-GMT )
   The local time zone
time-zone-minutes ( -- addr )
   Variable containing the number of minutes west of GMT; see TIME-ZONE
times ( n -- )
   Re-interpret this command line n times
title ( -- )
   Displays the name and version of the Forth system
to-column ( column -- )
   Advance output to indicated column
to-file ( -- )    filename
   Temporarily redirect output to a file
today ( -- day month year )
   Today's date
toggle ( addr byte-mask -- )
   Invert the masked bits within the byte at addr
token! ( addr2 addr1 -- )
   Store a relocatable address at addr1
token, ( addr -- )
   Place a relocatable address in the dictionary
token@ ( addr1 -- addr2 )
   Fetch a relocatable address
top! ( n stack -- )
   Replace the top number on a user stack
top@ ( stack -- n )
   Get the top number from a user stack without popping it
trap: ( function# trap# -- )    name
   Begin defining a word to execute a trap call
true ( -- -1 )
   The value TRUE , which is -1
tsearch ( addr start end -- loc true | false )
   Search for address addr between start-addr and end-addr
tuck ( n1 n2 -- n2 n1 n2 )
   Copy the top of the stack underneath the second item
tuser ( -- )    name
   Define and allocate space for a user variable to contain an address
type ( addr +n -- )
   Unsigned u1*u2
u. ( u  -- )
   Print an unsigned number
u.r ( u +n -- )
   Print unsigned number in fixed width field
u2/ ( u1 -- u2 )
   Logical right shift
u< ( u1 u2  --  flag )
   Unsigned version of < .
u<= ( u1 n2 -- flag )
   True if u1 is less than or equal to u2
u> ( u1 n2 -- flag )
   True if u1 is greater than u2
u>= ( u1 n2 -- flag )
   True if u1 is greater than or equal to u2
ualloc ( size -- new-user-number )
   Allocate space in the user area
ul* ( ul1 ul2 -- lproduct )
   Unsigned 32x32 -> 32 multiply
ul. ( ul -- )
   Display a 32-bit unsigned number
ul.r ( ul +n -- )
   Display a 32-bit unsigned number in a fixed-width field
um* ( uw1 uw2 -- ul )
   16 bits times 16 bits unsigned multiply
um/mod ( ul.dividend un.divisor -- un.rem un.quot )
   Unsigned 32/normal remainder/quotient
umax ( u1 u2 -- u3 )
   Unsigned maximum
umin ( u1 u2 -- u3 )
   Unsigned minimum
unnest ( -- )
   Return from a colon definition
until ( flag -- )
   Exit from BEGIN .. UNTIL loop if true
up ( -- )
   Move the cursor up one line
up! ( addr -- )
   Change the starting address of the user area
up0 ( -- addr )
   USER variable containing the starting address of the USER area
up@ ( --  addr )
   The starting address of the aser area
upc ( char -- upper-case-char )
   Convert to upper case
update ( -- )
   Not Implemented
upper ( addr len -- )
   Convert a string to upper case
user ( offset -- )    name
   Define a variable at the given offset in the user area
user-size ( -- n )
   The size in bytes of the USER area.
user-state ( -- )
   The processor is put into user state
variable ( -- )    name
   Define a variable
vec! ( addr vector-number -- )
   Install an interrupt/exception handler
vfind ( str voc-ptr -- cfa 1 )
   Search for a word in a single vocabulary
voc-link ( -- addr )
   USER variable containing the address of the last vocabulary created
vocabulary ( -- )    name
   Define a new vocabulary
vocs ( -- )
   Display the names of all vocabularies
w! ( n addr -- )
   Store a word at addr
w, ( w -- )
   Place a word in the dictionary
w->l ( uw -- l )
   Convert a an unsigned to 16-bit number to a 32-bit number
w@ ( addr -- w )
   Fetch the unsigned word at addr
wa+ ( addr1 index -- addr2 )
   Increment by index times the size of a word
wa1+ ( addr1 -- addr2 )
   Increment by the size of a word
warm ( -- )
   Restart Forth after a hardware exception
warm-hook ( -- )
   USER variable controlling "isn't Unique" messages
wconstant ( w -- )    name
   Define a 16-bit constant
wflip ( l1 -- l2 )
   Swap words with a longword
whatis ( -- )    word
   Display a brief description of the word
where ( -- )
   Exit from BEGIN .. WHILE .. REPEAT if false
within ( n min max -- f )
   True if n <= x < max
wljoin ( w.low w.high -- l )
   Join two words to form a longword
word ( char -- addr )
   Collect char-delimited input string
word-bounds ( acf -- apf addr )
   Find the start and end of a colon definition's body
words ( -- )
   Display the names of the words in the CONTEXT vocabulary
words ( -- )
   Display the words in the context vocabulary
write ( -- n )
   The code used by OPEN to mean the file is to be written
write-open ( name -- )
   Open file for writing; it must already exist
writing     filename
   Create a new file and open it for writing
wsearch ( w start end -- loc true | false )
   Search for 16-bit word w between start-addr and end-addr
wvariable ( -- )    name
   Begin defining a word to execute an extended BIOS function
xload ( -- )    filename
   Load the file and print a message to that effect
xor ( n1 n2 -- n3 )
   Exclusive or
zapaes ( -- )
   Get rid of the GEM AES; useless if TOS is in ROM
[ ( -- )
   Begin interpreting
[""] ( -- )    word
   Compile the characters of a word collected from the input stream
['] ( -- addr )
   Compile the compilation address of a word
[assembler] ( -- )
   Immediately select the assembler vocabulary
[compile] ( -- )
   Compile next word even if it's immediate
\ ( -- )    rest-of-line
   Comment to end of line
\c ( -- )    rest-of-line
   Comment to end of line; same as \
\dtc ( -- )
   Does nothing
\dtc ( -- )
   Ignore the rest of the line
\needs ( -- )    needed-word rest-of-line
   Ignore rest of line if needed-word is already defined
\t16 ( -- )
   Ignore the rest of the line
\t32 ( -- )
   Does nothing
] ( -- )
   Begin compiling
{ ( -- )    argument list}
   Begin the argument specification for BDOS:, etc
cal inversion
lnover ( l1 n -- l1 n l2 )
   Copy a longword over a normal
lnswap ( l n -- n l )
   Swap
◆◆